package main

import (
	"fmt"
	"log"
	"os"

	"github.com/gin-gonic/gin"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"crongo/config"
	"crongo/internal/api"
	"crongo/internal/i18n"
	"crongo/internal/middleware"
	"crongo/internal/model"
	"crongo/internal/service"
)

var (
	Version   = "dev"
	BuildTime = "unknown"
	CommitID  = "unknown"
)

func init() {
	// 初始化国际化支持
	if err := i18n.InitMessages(); err != nil {
		log.Fatalf("Failed to initialize i18n: %v", err)
	}
}

func main() {
	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
	log.Printf("CronGo 定时任务管理系统 v%s (构建时间: %s, 提交ID: %s)", Version, BuildTime, CommitID)

	// 加载配置文件
	log.Println("正在加载配置文件...")
	if err := config.LoadConfig(); err != nil {
		log.Printf("加载配置文件失败: %v", err)
		log.Println("将使用默认配置")
	}

	// 初始化数据库
	log.Println("正在连接数据库...")
	db, err := initDB()
	if err != nil {
		log.Fatalf("连接数据库失败: %v", err)
	}
	log.Println("数据库连接成功")

	// 自动迁移数据库结构
	log.Println("正在进行数据库迁移...")
	err = db.AutoMigrate(&model.Task{}, &model.TaskLog{})
	if err != nil {
		log.Fatalf("数据库迁移失败: %v", err)
	}
	log.Println("数据库迁移完成")

	// 创建日志目录
	log.Println("正在初始化日志目录...")
	if err := os.MkdirAll(config.GlobalConfig.Log.Dir, 0755); err != nil {
		log.Fatalf("创建日志目录失败: %v", err)
	}

	// 初始化服务
	log.Println("正在初始化任务服务...")
	taskService := service.NewTaskService(db)

	// 启动所有启用状态的任务
	log.Println("正在启动已启用的任务...")
	if err := taskService.StartAllTasks(); err != nil {
		log.Printf("启动任务失败: %v", err)
	}

	// 设置路由
	log.Println("正在设置路由...")
	r := gin.Default()

	// 注册中间件
	r.Use(middleware.I18nMiddleware())

	// 静态文件路由（不需要认证）
	r.Static("/static", "web/static")
	r.LoadHTMLGlob("web/templates/*")

	// 登录页面（不需要认证）
	r.GET("/login", func(c *gin.Context) {
		c.HTML(200, "login.html", nil)
	})

	// Web页面（需要认证检查）
	r.GET("/", middleware.JWTAuthMiddleware(), func(c *gin.Context) {
		// 从上下文获取国际化消息
		msg := c.MustGet("i18n").(*i18n.Message)
		c.HTML(200, "index.html", gin.H{
			"i18n": msg,
		})
	})
	r.GET("/task-logs", middleware.JWTAuthMiddleware(), func(c *gin.Context) {
		c.HTML(200, "logs.html", nil)
	})

	// 初始化处理器
	taskHandler := api.NewTaskHandler(db, taskService)

	// API路由组（需要认证）
	apiGroup := r.Group("/api", middleware.JWTAuthMiddleware())
	{
		// 任务管理
		apiGroup.GET("/tasks", taskHandler.ListTasks)
		apiGroup.POST("/tasks", taskHandler.CreateTask)
		apiGroup.PUT("/tasks/:id", taskHandler.UpdateTask)
		apiGroup.DELETE("/tasks/:id", taskHandler.DeleteTask)
		apiGroup.GET("/task-groups", taskHandler.GetTaskGroups)
		apiGroup.GET("/tasks/:id", taskHandler.GetTask)

		// 任务运行记录
		apiGroup.GET("/task-logs", taskHandler.GetRecentLogs)
		apiGroup.GET("/tasks/:id/task-logs", taskHandler.GetTaskLogs)

		// 任务输出日志
		apiGroup.GET("/tasks/:id/output", taskHandler.GetTaskLogFile)
		apiGroup.GET("/tasks/:id/task-logs/:log_id/output", taskHandler.GetTaskLogFile)
	}

	// 登录API（不需要认证）
	r.POST("/api/login", api.LoginHandler)

	// 启动服务器
	addr := fmt.Sprintf("%s:%d", config.GlobalConfig.Server.Host, config.GlobalConfig.Server.Port)
	log.Printf("服务启动完成，监听地址: %s", addr)
	log.Printf("请访问 http://%s 使用系统", addr)
	if err := r.Run(addr); err != nil {
		log.Fatalf("服务器启动失败: %v", err)
	}
}

// initDB 初始化数据库连接
func initDB() (*gorm.DB, error) {
	var dialector gorm.Dialector
	cfg := config.GlobalConfig.Database

	switch cfg.Type {
	case "sqlite":
		dialector = sqlite.Open(cfg.DSN)
	default:
		return nil, fmt.Errorf("不支持的数据库类型: %s", cfg.Type)
	}

	logLevel := logger.Info
	switch cfg.LogLevel {
	case "silent":
		logLevel = logger.Silent
	case "error":
		logLevel = logger.Error
	case "warn":
		logLevel = logger.Warn
	}

	return gorm.Open(dialector, &gorm.Config{
		Logger: logger.Default.LogMode(logLevel),
	})
}
